import { model } from '.';
import {
  PeriodType,
  ReceptionType,
} from './enum';
import { FileItemShare, ReceptionStatusModel,ValidateErrorInfo } from './model';
export type Xbase = {
  // 雪花ID
  id: string
  // 状态
  status: number
  // 创建人员ID
  createUser: string
  // 更新人员ID
  updateUser: string
  // 修改次数
  version: string
  // 创建时间
  createTime: string
  // 更新时间
  updateTime: string
  // 共享用户ID
  shareId: string
  // 归属用户ID
  belongId: string
}
export interface XValidation extends XThing, ValidateErrorInfo {
  typeName: '校验信息';
  formId?: string;
  /** 流程实例ID */
  instanceId: string;
  /** 强审理由 */
  reason: string;
  /** 附件 */
  files?: FileItemShare[];
}

// 接收
export interface XReception extends XEntity, ReceptionStatusModel {
  typeName: ReceptionType;
  /** 储存任务文件的群，不一定是接收的群 */
  sessionId: string;
  /** 任务 */
  taskId: string;
  /** 分发ID */
  distId: string;
  /** 任务周期 */
  periodType: PeriodType;
  /** 数据时期 */
  period: string;
  /** 接收内容 */
  content: model.ReceptionContentBase<model.TaskContentType>;
  /** 草稿 */
  draftId?: string;
  /** 分发树当前根节点ID */
  taskTreeCurRootNodeId?: string;
}
export type XCache = {
  // 完整的ID标识
  fullId: string
  // 标签
  tags?: string[]
}

export type XEntity = {
  // 名称
  name: string
  // 编号
  code: string
  // 备注
  remark: string
  // 图标
  icon: string
  // 类型
  typeName: string
  // 标签组
  labels?: string[];
  /** 快捷方式目标 */
  sourceId?: string
  // 创建类别标准的用户
  belong: XTarget | undefined
} & Xbase

//应用定义
export type XStandard = {
  // 目录ID
  directoryId: string
  // 是否删除
  isDeleted: boolean;
  // 排序
  sort: string;
} & XEntity

// 常用定义
export type XCommon = {
  // 唯一标识
  id: string
  // 空间ID
  spaceId: string
  // 用户ID
  targetId: string
  // 目录ID
  directoryId: string
  // 应用ID
  applicationId: string
  // 文件类型
  typeName: string;
  // 分组信息
  groupName?: string
}
// 排序存储
export type Sort = {
  // 顺序
  sort: number;
  // id
  id: string;
};
/** 容器 */
export type XContainer = {
  // 排序
  sorts: Sort[] | undefined;
} & XStandard;
//应用定义
export type XApplication = {
  // 父ID
  parentId: string
  // 应用资源
  resource: string
  // 应用下的办事
  defines: XWorkDefine[] | undefined
  // 应用的结构
  parent: XApplication | undefined
  // 应用的结构
  nodes: XApplication[] | undefined
  // 应用的目录
  directory: XDirectory | undefined
  // 应用的banners
  banners?: string | undefined;
  // 权限id
  applyAuths: string[];
} & XContainer

//特性和属性的关系
export type XAttrLinkProp = {
  // 特性ID
  attrId: string
  // 属性ID
  propId: string
  // 归属用户ID
  belongId: string
  // 关联的属性
  property: XProperty | undefined
  // 关联的特性
  attribute: XAttribute | undefined
} & Xbase

//度量特性定义
export type XAttribute = {
  // 名称
  name: string;
  // 编号
  code: string;
  // 规则
  rule: string;
  // 备注
  remark: string;
  // 工作职权Id
  authId: string;
  // 属性Id
  propId: string;
  // 单Id
  formId: string;
  // 虚拟列规则
  queryRule: string;
  // 归属用户ID
  belongId: string;
  // 特性显示组件
  widget?: string;
  // 特性值类型
  valueType?: string;
  // 关联属性
  property: XProperty | undefined;
  // 配置参数
  options: XAttributeProps | undefined;
  // 关联的分类ID
  speciesId?: string;
} & Xbase;

// 度量特性配置参数
export type XAttributeProps = {
  /** 表单参数 */
  // 是否可设置空值
  allowNull?: boolean;
  // 是否只读
  readOnly?: boolean;
  // 是否只读条件
  readOnlyConditions?: model.conditionConfig;
  // 是否必填
  isRequired?: boolean;
  // 是否必填条件
  isRequiredConditions?: model.conditionConfig;
  // 隐藏特性
  hideField?: boolean;
  // 根据其它表单相同code值改变
  changeWithCode?: XForm[];
  // 字段匹配依据
  changeWithCodeField?: boolean;
  // 隐藏条件
  hideFieldConditions?: model.conditionConfig;
  // 默认值
  defaultValue?: any;
  // 成员的上级组织
  teamId?: string;
  // 是否限定为操作主体
  isOperator?: boolean;
  /** 表格参数 */
  // 是否可见
  visible?: boolean;
  // 是否显示在左侧分类列
  species?: boolean;
  // 是否固定列
  fixed?: boolean;
  // 是否展示至摘要
  showToRemark?: boolean;
  // 是否开启搜索
  searchEnabled?: boolean;
  // 是否自动生成值
  isAsyncVal?: boolean;
  // 是否选择时 空值自动生成值
  autoSelectedFill?: boolean;
  // 是否内置字段
  isNative?: boolean;
  // 自动生成值
  asyncGeneateConditions?: model.Encode[];
  // 资产拆分自动生成值
  asyncSplitConditions?: model.Encode[];
  // 展示格式(日期、时间等)
  displayFormat?: string;
  // 展示默认列宽
  defaultWidth?: number;
  // 是否汇总计算
  isSummary?: boolean;
  // 排序（升序、降序）
  sortOrder?: 'asc' | 'desc';
  // 数字型精度
  accuracy?: number;
  // 多级选择框展示类型
  displayType?: number | undefined;
  // 是否只能选择末级节点
  isSelectLastLevel?: boolean;
  // 规则提示语
  rulePrompt?: string;
  // 报表临时属性坐标
  reportTemporaryCoord?: string;
  // 默认类型
  defaultType?: string;
  /** 标记计算属性（用于报表单元格颜色） */
  isComputed?: boolean;
  // 用户型数据 是否在列表展示编码
  showCode?: boolean;
  // 筛选其他数据的属性
  viewFilterKey?: string;
  /** 最大值 */
  min?: any;
  /** 最小值 */
  max?: any;
  /** 范围 */
  dateRange?: any;
  /** 绑定节点 */
  bindNode?: string;
};

//权限定义
export type XAuthority = {
  // 公开的
  public: boolean
  // 上级权限ID
  parentId: string
  // 共享用户ID
  shareId: string
  // 上下级权限
  parent: XAuthority | undefined
  // 上下级权限
  nodes: XAuthority[] | undefined
  // 权限对应的身份
  identitys: XIdentity[] | undefined
  // 权限可操作的度量
  autAttrs: XAttribute[] | undefined
} & XEntity

//目录定义
export type XDirectory = {
  // 共享用户ID
  shareId: string
  // 目录下的属性
  propertys: XProperty[] | undefined
  // 目录下的单
  forms: XForm[] | undefined
  // 目录下的分类
  species: XSpecies[] | undefined
  // 目录下的应用
  applications: XApplication[] | undefined
  // 目录的结构
  parent: XDirectory | undefined
  // 目录的结构
  nodes: XDirectory[] | undefined
} & XContainer

//表单定义
export type XForm = {
  [key: string]: any;
  // 表单布局
  rule: model.Rule[];
  // 配置参数
  options: XFormProps | undefined;
  // 表单的特性
  attributes: XAttribute[];
  // 报表的填报周期
  cycle?: string | undefined;
  // 报表的内容
  reportDatas: string;
  // 存储的集合名称
  collName: string | undefined;
  // 应用Id(应用内的表单)
  applicationId?: string;
  // 导入匹配
  matchImport?: string;
  // 分组展示
  groups?: XGroups[];
} & XStandard &
  model.IDocumentConfigHost;
export interface XGroups {
  name: string;
  index: number;
  valueType: '分组型';
}
// 表单规则
export type XFormRule1 = {
  id: string
  name: string
  type: 'show' | 'calc'
  trigger: string[]
  target: string
  remark: string
}

// 表单展示规则
export type FormShowRule = {
  showType: string
  value: boolean
  condition: string
} & XFormRule1

// 表单计算规则
export type FormCalcRule = {
  formula: string
} & XFormRule1
export type XFormFilter = {
  filterRedRow?: string;
  filterRedRowExp?: string;
  filterExp?: string;
  filterDisplay?: string;
  classifyExp?: string;
  classifyDisplay?: string;
  authExp?: string;
  authDisplay?: string;
  groupExp?: string;
  groupDisplay?: string;
  groupId?: string;
  clusterId?: string; // 数据集群Id
};
// 度量特性配置参数
export type XFormProps = {
  // 常规项宽度
  itemWidth: number;
  // 数据范围限制
  dataRange?: XFormFilter;
  // 办事数据范围限制
  workDataRange?: XFormFilter;
  //视图权限过滤参数
  viewDataRange?: { company: string; department: string; person: string };
  // // 属性过滤
  // attributeFilter?: string
  // 业务类型
  businessType?: string;
  //是否允许集群成员查看
  allowMemberView?: boolean;
};

/* 表单规则类型 */
export type XFormRule = {
  id: string
  /* 规则名称 */
  name: string
  /* 规则类型 */
  ruleType: 'method' | 'formula'
  /* 触发方式 初始化-修改时-提交时 */
  trigger: 'Start' | 'Running' | 'Submit'
  /* 规则支持的数据类型 */
  accept: string[]
  /* 规则关联特性 */
  linkAttrs: any[]
  /* 关联项最大数量 */
  max?: number
  /* 规则是否可扩展关联项 */
  isExtend: boolean
  /* 错误提示 */
  errorMsg: string
  /* 规则执行函数构造器 */
  creatFun?: string
  /* 规则执行函数 */
  content: Function
  /* 备注 */
  remark: string
}
/* 表单规则类型 */
export type FormRuleType = {
  /* 规则数据 */
  list: XFormRule[]
  /* 设计展示数据 */
  schema: any
}
/* 表单特性规则类型 */
export type AttrRuleType = {
  /* 标题 */
  name: string
  /* 编号 */
  code: string
  /* 字段是否显示在输入区域 */
  hidden?: boolean
  /* 字段是否只读 */
  readonly?: boolean
  /*是否必填 */
  required?: boolean
  allowClear?: boolean
  maxLength?: number
  minLength?: number
  /* 数值类型 最小值 */
  min?: number
  /* 数值类型 最大值 */
  max?: number
  /* 展示组件类型 */
  widget?: string
  /* 输入提示 */
  placeholder?: string
  /* 管理权限 */
  authId?: string
  /* 特性定义 */
  remark?: string
  /* 正则校验 */
  rules: string
  /* 规则数据 */
  list?: XFormRule[]
  /*  设计展示数据 */
  schema: any
}
export interface XDocumentTemplate extends XStandard {
  typeName: '文档模板';
  // 应用内的打印模板id
  applicationId?: string;
}
//报表定义
export type XReport = {
  // 表单布局
  rule: model.Rule[];
  // 配置参数
  options: XFormProps | undefined;
  // 报表的属性
  attributes: XAttribute[];
  // 报表的内容
  sheets: {
    [key: string]: XSheet;
  };
  // 存储的集合名称
  collName: string | undefined;
  // 报表版本id
  reportId: string;
  // 应用Id(应用内的报表)
  applicationId?: string;
  // 变量集
  variables?: XVariables;
  // 发起权限
  applyAuths: string[];
} & XStandard &
  model.IDocumentConfigHost;
export type XVariables = {
  [key: string]: XVariable;
};
export type XVariable = {
  value?: {
    // 值类型
    type: string;
    // 值
    valueString: any;
  };
};
//报表sheets定义
export type XSheet = {
  cells: XSheetCells;
  // sheet页的名称
  name: string;
  // sheet页的code
  code: string;
  // sheet页属性id
  attributeId?: string;
  // sheet页的配置
  sheetConfig: XSheetConfig;
};
//报表sheet单元格配置
export type XSheetCells = {
  [key: string]: XCells;
};

export type XCells = {
  // 列的坐标
  col: number;
  // 行的坐标
  row: number;
  // 只读
  readOnly?: boolean;
  // 精度
  accuracy?: number;
  // 校验规则
  rule: XCellRule;
  // 单元格类型
  valueType?: string;
  // 单元格缓存值
  cacheValue?: string;
  // class样式
  class?: { [key: string]: string };
  // style样式
  style?: { [key: string]: string };
  // sheet表的code
  code?: string;
};

export type XCellRule = {
  // 是否必填
  isRequired?: boolean;
  // 是否计算汇总
  isSummary?: boolean;
  // 校验规则
  ruleString?: string;
  // 是否变量集取数
  isVariableData?: boolean;
  // 单元格值
  value?: {
    // 值类型
    type: string;
    // 值
    valueString: any;
  };
};

//报表sheet配置定义
export type XSheetConfig = {
  // 合并的单元格
  mergeCells?: any[];
  // sheet页行高
  row_h?: string[];
  // sheet页列宽
  col_w?: string[];
  // 浮动行设置
  floatRowsSetting?: XFloatRowsInfo[];
  // sheet页列数
  minCols?: number;
  // sheet页行数
  minRows?: number;
};
export type XFloatRowsInfo = {
  // 坐标
  coords: string;
  // 代码
  floatRowCode: string;
  // 是否浮动行
  isFloatRows: boolean;
  // 浮动行起始行
  floatStartLine: number;
  // 浮动行数
  floatRowNumber: number;
  // 列字段
  rowsInfo: XRowsInfo[];
  // 起始列
  startColumn: number;
  // 需要合并的单元格
  mergeCells: any;
  // 子表的单元格宽度集合
  colWidths: any;
  // 浮动行对象型id
  attributeId?: string;
  // sheet表的code
  code?: string;
};

export type XRowsInfo = {
  // 字段名
  name: string;
  // 单元格列数
  index: number;
  // 单元格类型
  valueType?: string;
  // 校验规则
  rule: XCellRule;
  // 精度
  accuracy?: number;
  // 是否只读
  isOnlyRead?: boolean;
  // 行次
  isLineNumber?: boolean;
  // 起始行次
  startLineNumber?: number;
};

//身份证明
export type XIdProof = {
  // 身份ID
  identityId: string
  // 对象ID
  targetId: string
  // 岗位Id
  teamId: string
  // 身份证明证明的用户
  target: XTarget | undefined
  // 身份证明证明的身份
  identity: XIdentity | undefined
} & Xbase

//身份
export type XIdentity = {
  // 职权Id
  authId: string
  // 共享用户ID
  shareId: string
  // 身份证明
  idProofs: XIdProof[] | undefined
  // 身份集关系
  identityTeams: XTeamIdentity[] | undefined
  // 赋予身份的用户
  givenTargets: XTarget[] | undefined
  // 身份集对于组织
  teams: XTeam[] | undefined
  // 身份的类别
  authority: XAuthority | undefined
  // 共享用户
  share: XTarget | undefined
} & XEntity

//属性定义
export type XProperty = {
  // 值类型
  valueType: string;
  // 附加信息
  info: string;
  // 计量单位
  unit: string;
  // 标签ID
  speciesId: string;
  // 表单id
  formId?: string;
  // 来源用户ID
  sourceId: string;
  // 给物的度量标准
  linkAttributes: XAttribute[] | undefined;
  // 特性关系
  links: XAttrLinkProp[] | undefined;
  // 创建的特性集
  attributes: XAttribute[] | undefined;
  // 附加过属性的物
  things: XThing[] | undefined;
  // 属性的物的度量
  propThingValues: XThingProp[] | undefined;
  // 属性的目录
  directory: XDirectory | undefined;
  // 字典类型
  species: XSpecies | undefined;
  // 序列类型
  sequence?: XSequence | undefined;
  // 变更目标
  isChangeTarget: boolean;
  // 变更源
  isChangeSource: boolean;
  // 标记拆分或合并
  isCombination: boolean;
} & XStandard;

//用户关系
export type XRelation = {
  // 对象ID
  targetId: string
  // 组织ID
  teamId: string
  // 关联的组织团队
  team: XTeam | undefined
  // 关联的组织实体
  target: XTarget | undefined
} & Xbase

//分类标签
export type XSpecies = {
  // 来源用户ID
  sourceId: string;
  // 组织 ID
  generateTargetId: string;
  // 分类的标签
  tags: '应用分类' | '组织分类' | '';
  // 分类的类目
  speciesItems: XSpeciesItem[] | undefined;
  // 使用该分类的度量属性
  speciesProps: XProperty[] | undefined;
  // 分类的目录
  directory: XDirectory | undefined;
  // 字典 | 人员分类
  isPersonnel?: boolean;
} & XStandard;

//分类类目
export type XSpeciesItem = {
  // 附加信息
  info: string;
  // 父类目ID
  parentId: string;
  // 分类ID
  speciesId: string;
  // 字典类型
  species: XSpecies | undefined;
  // 类目的结构
  parent: XSpeciesItem | undefined;
  // 类目的结构
  nodes: XSpeciesItem[] | undefined;
  // 关联id
  relevanceId?: string;
} & XEntity;

//用户
export type XTarget = {
  // 雪花ID
  id: string;
  // 名称
  name: string;
  // 编号
  code: string;
  // 备注
  remark: string;
  // 图标
  icon: string;
  // 类型
  typeName: string;
  // 归属用户ID
  belongId: string;
  // 开放组织
  public: boolean;
  // 存储
  storeId: string;
  // 状态
  status: number;
  // 创建人员ID
  createUser: string;
  // 更新人员ID
  updateUser: string;
  // 修改次数
  version: string;
  // 创建时间
  createTime: string;
  // 更新时间
  updateTime: string;
  // 创建类别标准的用户
  belong: XTarget | undefined;
  // 身份证明
  idProofs: XIdProof[] | undefined;
  // 组织的身份
  shareIdentitys: XIdentity[] | undefined;
  // 归属的身份
  identitys: XIdentity[] | undefined;
  // 加入团队的关系
  relations: XRelation[] | undefined;
  // 作为团队的影子
  team: XTeam | undefined;
  // 该用户创建的职权标准
  authority: XAuthority[] | undefined;
  // 加入的团队
  relTeams: XTeam[] | undefined;
  // 赋予该用户创建的身份
  givenIdentitys: XIdentity[] | undefined;
  // 该组织或个人所属的用户
  targets: XTarget[] | undefined;
} & XEntity;

//虚拟组织
export type XTeam = {
  // 名称
  name: string
  // 编号
  code: string
  // 实体
  targetId: string
  // 加入团队的用户
  relTargets: XTarget[] | undefined
  // 组织身份集关系
  teamIdentitys: XTeamIdentity[] | undefined
  // 加入团队的用户的关系
  relations: XRelation[] | undefined
  // 团队的实体
  target: XTarget | undefined
  // 组织的身份集
  identitys: XIdentity[] | undefined
} & Xbase

//用户身份
export type XTeamIdentity = {
  // 身份ID
  identityId: string
  // 用户ID
  teamId: string
  // 身份加入的组织
  team: XTeam | undefined
  // 组织包含的身份
  identity: XIdentity | undefined
} & Xbase

//(物/存在)
export type XThing = {
  // 链上ID
  chainId: string
  // 名称
  name: string
  // 编号
  code: string
  // 共享容器ID
  shareId: string
  // 归属用户ID
  belongId: string
  // 备注
  remark: string
  /** 标签集 */
  [property: string]: any
  /** 归档集 */
  archives: {
    [time: string]: any
  }
  // 物的属性集
  thingPropValues: XThingProp[] | undefined
  // 物作为管理对象的映射
  target: XTarget | undefined
  // 给物的度量标准
  givenPropertys: XProperty[] | undefined
  // 物的归属
  belong: XTarget | undefined
} & Xbase

//物的属性值
export type XThingProp = {
  // 属性ID
  propId: string
  // 元数据ID
  thingId: string
  // 值
  value: string
  // 度量的标准
  property: XProperty | undefined
  // 度量的物
  thing: XThing | undefined
} & Xbase

//办事定义
export type XWorkDefine = {
  // 规则
  rule: string;
  // 主办事ID
  masterId: string;
  // 共享用户ID
  shareId: string;
  // 允许补充办事
  hasGateway: boolean;
  // 发起权限
  applyAuth: string;
  // 应用ID
  applicationId: string;
  // 来源Id
  sourceId: string;
  // 办事定义节点
  nodes: XWorkNode[] | undefined;
  // 办事的实例
  instances: XWorkInstance[] | undefined;
  // 应用
  application: XApplication | undefined;
  // 归属用户
  target: XTarget | undefined;
  // 办事打开类型
  applyType: string;
  // 是否允许直接办事
  allowInitiate: boolean;
  // 是否私有，不允许跨流程查看
  isPrivate: boolean;
  // 是否允许短信催办
  canUrge: boolean;
  // 主Id
  primaryId: string;
} & XStandard;

//节点网关
export type XWorkGateway = {
  // 网关节点Id
  nodeId: string
  // 关联办事Id
  defineId: string
  // 组织Id
  targetId: string
  // 关联的办事
  define: XWorkDefine | undefined
  // 关联的办事
  identity: XIdentity | undefined
} & Xbase

//办事实例
export type XWorkInstance = {
  // 标题
  title: string
  // 办事定义Id
  defineId: string
  // 展示内容类型
  contentType: string
  // 对应父流程实例的节点任务
  taskId: string
  // 展示内容
  content: string
  // 携带的数据
  data: string
  // 回调钩子
  hook: string
  // 申请用户ID
  applyId: string
  // 共享用户ID
  shareId: string
  // 办事定义的共享用户ID
  defineShareId: string
  // 归属用户ID
  belongId: string
  // 备注
  remark: string
  // 办事任务
  tasks: XWorkTask[] | undefined
  // 办事的定义
  define: XWorkDefine | undefined
  // 归属用户
  target: XTarget | undefined
} & Xbase

//办事定义节点
export type XWorkNode = {
  // 节点规则
  rule: string
  // 节点编号
  code: string
  // 节点名称
  name: string
  // 审批人数
  count: number
  // 办事定义Id
  defineId: string
  // 节点分配目标Id
  destId: string
  // 节点分配目标名称
  destName: string
  // 兄弟节点Id集合
  brotherIds: string
  // 分支Id
  branchId: string
  // 分支类型
  branchType: number
  // 备注
  remark: string
  // destType
  destType: string
  // 节点类型
  nodeType: string
  // 办事实例任务
  tasks: XWorkTask[] | undefined
  // 赋予身份的用户
  bindFroms: XForm[] | undefined
  // 办事的定义
  define: XWorkDefine | undefined
} & Xbase

//办事节点绑定
export type XWorkNodeRelation = {
  // 单类型
  fromType: string
  // 办事节点
  nodeId: string
  // 单设计
  formId: string
} & Xbase

//办事节点数据
export type XWorkRecord = {
  // 节点任务
  taskId: string
  // 评论
  comment: string
  // 内容
  data: string
  // 办事的定义
  task: XWorkTask | undefined
} & Xbase

//办事任务
export type XWorkTask = {
  // 任务标题
  title: string
  // 审批类型
  approveType: string
  // 任务类型
  taskType: string
  // 审批人数
  count: number
  // 审批身份Id
  identityId: string
  // 办事定义节点id
  nodeId: string
  // 办事实例id
  instanceId: string
  // 流程任务Id
  defineId: string
  // 任务的用户Id
  shareId: string
  // 归属用户ID
  belongId: string
  // 申请用户ID
  applyId: string
  // 内容
  content: string
  // 备注
  remark: string
  // 办事节点记录
  records: XWorkRecord[] | undefined
  // 办事节点
  node: XWorkNode | undefined
  // 办事的定义
  instance: XWorkInstance | undefined
} & Xbase

//暂存
export type XStaging = {
  // 类型
  typeName: string
  // 数据
  data: XThing
  // 归属+关系举证
  relations: string
} & Xbase

// 页面模板
export interface XPageTemplate extends XStandard {
  // 是否发布至门户
  public: boolean
  // 是否公开
  open: boolean
  // 模板类型
  kind?: string
}
// 变更历史
export interface XRevision<T extends XEntity> extends XEntity {
  // 操作
  operate: string;
  // 所在集合
  collName: string;
  // 变更数据
  data: T;
}
export interface XSyncing extends XEntity {
  // 最新同步时间
  syncTime: string;
}
// 同步
export interface XSubscription extends XSyncing {
  // 类型
  typeName: string;
  // 发布用户
  target: XTarget;
  // 关系
  relations: string[];
  // 是否取消了
  canceled: boolean;
}
export type XFileLink = {
  // 文件目录id
  directoryId: string;
} & model.FileItemModel &
  Xbase;
export type XSequence = {
  //应用ID
  applicationId: string;
  // 初始值
  initValue: number;
  // 递增值
  increament: number;
  // 循环选项
  circleOpt?: string;
  // 循环条件
  conditionOpt?: string;
  // 条件值
  conditionValue: number;
  // 刷新时间
  resetTime: string;
  // 是否缓存
  isCache: boolean;
  // 当前值
  value: number;
  // 长度
  length: number;
} & XStandard;